package com.kk.demo.java8.stream.base01.collectorimp;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Stream;

/**
 * 开始使用stream并带有reduce
 * @author liujun
 * @date 2016年8月28日
 * @verion 0.0.1
 */
public class StreamCollectorUseReduceMap {

    public StreamCollectorUseReduceMap() {
    }

    public static void main(String[] args) {
        StreamCollectorUseReduceMap stream = new StreamCollectorUseReduceMap();
        stream.mapCollectorProcess(stream.getStream());
    }

    /**
     * 得到Stream对象
     * @return
     */
    public Stream<String> getStream() {
        // 声明一个集合
        List<String> arrayInt = Arrays.asList("1,1000", "1,200", "1,300", "2,100", "2,200", "3,100");
        // 通过集合得到一个stream对象
        Stream<String> intStream = arrayInt.stream();

        return intStream;
    }

    /**
     * 进行运算
     * @param input
     */
    public void mapCollectorProcess(Stream<String> input) {

        Map<Integer, List<Integer>> map = input.parallel().collect(HashMap<Integer, List<Integer>>::new,
                this::getMapPrcess, this::parllCount);
        System.out.println(map);
    }

    /**
     * 得到进行map处理的方法
     * @param key 输入的行记录
     * @return 结果的map信息
     */
    public Map<Integer, List<Integer>> getMapPrcess(Map<Integer, List<Integer>> map, String key) {
        String[] arrayks = key.split(",");
        int a1 = Integer.parseInt(arrayks[0]);
        int a2 = Integer.parseInt(arrayks[1]);

        List<Integer> keyValueArray = null;

        if (map.containsKey(a1)) {
            keyValueArray = map.get(a1);
        } else {
            keyValueArray = new ArrayList<>();
        }
        keyValueArray.add(a2);

        map.put(a1, keyValueArray);

        return map;
    }

    /**
     * 进行多路的情况下的计算
     * @param a 输入参数信息
     * @param b 当前的map信息
     * @return 结果信息
     */
    public Map<Integer, List<Integer>> parllCount(Map<Integer, List<Integer>> a, Map<Integer, List<Integer>> b) {

        System.out.println("当前A:" + a);
        System.out.println("当前B:" + b);

        if (null != a && null != b) {
            Iterator<Entry<Integer, List<Integer>>> iterReduce = b.entrySet().iterator();

            Entry<Integer, List<Integer>> entry = null;

            while (iterReduce.hasNext()) {
                entry = iterReduce.next();

                // 检查是否包含b中的key信息
                if (a.containsKey(entry.getKey())) {
                    List<Integer> value = a.get(entry.getKey());

                    int valuecount = entry.getValue().get(0) + value.get(0);

                    value.clear();
                    value.add(valuecount);

                    a.put(entry.getKey(), value);
                }
                // 如果不包含，则新加入
                else {
                    a.put(entry.getKey(), entry.getValue());
                }
            }
        }

        return a;
    }

}
